package com.ourteam.product.requirement.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-05-03 16:45:26
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductGlossaryChangLogDAOQueryBean extends BaseQueryBean {
    public ProductGlossaryChangLogDAOQueryBean() {
        super();
    }

    public ProductGlossaryChangLogDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductGlossaryChangLogDAOQueryBean(BaseQueryBean aQueryBean,
        Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.Id, "id");
        }
    }

    public void addAfterChangeContentSelectProperty() {
        addAfterChangeContentSelectProperty("afterChangeContent");
    }

    public void addAfterChangeContentSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.AfterChangeContent,
                aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.AfterChangeContent,
                "afterChangeContent");
        }
    }

    public void addApproverIdSelectProperty() {
        addApproverIdSelectProperty("approverId");
    }

    public void addApproverIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.ApproverId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.ApproverId,
                "approverId");
        }
    }

    public void addBeforChangeContentSelectProperty() {
        addBeforChangeContentSelectProperty("beforChangeContent");
    }

    public void addBeforChangeContentSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.BeforChangeContent,
                aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.BeforChangeContent,
                "beforChangeContent");
        }
    }

    public void addChangeReasonSelectProperty() {
        addChangeReasonSelectProperty("changeReason");
    }

    public void addChangeReasonSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.ChangeReason, aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.ChangeReason,
                "changeReason");
        }
    }

    public void addEditorIdSelectProperty() {
        addEditorIdSelectProperty("editorId");
    }

    public void addEditorIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.EditorId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.EditorId, "editorId");
        }
    }

    public void addEditDateSelectProperty() {
        addEditDateSelectProperty("editDate");
    }

    public void addEditDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.EditDate, aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.EditDate, "editDate");
        }
    }

    public void addProductGlossaryIdSelectProperty() {
        addProductGlossaryIdSelectProperty("productGlossaryId");
    }

    public void addProductGlossaryIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.ProductGlossaryId,
                aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.ProductGlossaryId,
                "productGlossaryId");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.Remarks, aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.Remarks, "remarks");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryChangLogDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductGlossaryChangLogDAO.Status, "status");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addAfterChangeContentSelectProperty();

        addApproverIdSelectProperty();

        addBeforChangeContentSelectProperty();

        addChangeReasonSelectProperty();

        addEditorIdSelectProperty();

        addEditDateSelectProperty();

        addProductGlossaryIdSelectProperty();

        addRemarksSelectProperty();

        addStatusSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductGlossaryChangLogDAOQueryBean> {
        protected Criteria(ProductGlossaryChangLogDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.Id + " is not null AND " +
                IProductGlossaryChangLogDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.Id + " is null OR " +
                IProductGlossaryChangLogDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " is null OR " +
                IProductGlossaryChangLogDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Id + " in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Id + " not in",
                    values, "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Id + " in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Id + " not in",
                    values, "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " not between",
                value1, value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.Id + " not between",
                value1, value2, "id");

            return this;
        }

        public Criteria andAfterChangeContentIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " is null");

            return this;
        }

        public Criteria andAfterChangeContentIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " is not null");

            return this;
        }

        public Criteria andAfterChangeContentIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " is not null AND " +
                IProductGlossaryChangLogDAO.AfterChangeContent + " <> ''");

            return this;
        }

        public Criteria andAfterChangeContentIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.AfterChangeContent +
                " is null OR " +
                IProductGlossaryChangLogDAO.AfterChangeContent + " = '')");

            return this;
        }

        public Criteria andAfterChangeContentEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " = ", value, "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.AfterChangeContent);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAfterChangeContentEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentNotEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " <>", value, "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " is null OR " +
                IProductGlossaryChangLogDAO.AfterChangeContent + " <>", value,
                "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.AfterChangeContent);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAfterChangeContentNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentGreaterThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent + " >",
                value, "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.AfterChangeContent);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAfterChangeContentGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " >=", value, "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.AfterChangeContent);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAfterChangeContentGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentLessThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent + " <",
                value, "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.AfterChangeContent);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAfterChangeContentLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " <=", value, "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.AfterChangeContent);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAfterChangeContentLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " like", buffer.toString(), "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " not like", buffer.toString(), "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentIn(List<String> values) {
            if (values.size() == 1) {
                return andAfterChangeContentEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                    " in", values, "afterChangeContent");

                return this;
            }
        }

        public Criteria andAfterChangeContentNotIn(List<String> values) {
            if (values.size() == 1) {
                return andAfterChangeContentNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                    " not in", values, "afterChangeContent");

                return this;
            }
        }

        public Criteria andAfterChangeContentIn(String[] values) {
            if (values.length == 1) {
                return andAfterChangeContentEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                    " in", Arrays.asList(values), "afterChangeContent");

                return this;
            }
        }

        public Criteria andAfterChangeContentNotIn(String[] values) {
            if (values.length == 1) {
                return andAfterChangeContentNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                    " not in", Arrays.asList(values), "afterChangeContent");

                return this;
            }
        }

        public Criteria andAfterChangeContentIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andAfterChangeContentBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " between", value1, value2, "afterChangeContent");

            return this;
        }

        public Criteria andAfterChangeContentNotBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryChangLogDAO.AfterChangeContent +
                " not between", value1, value2, "afterChangeContent");

            return this;
        }

        public Criteria andApproverIdIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " is null");

            return this;
        }

        public Criteria andApproverIdIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                " is not null");

            return this;
        }

        public Criteria andApproverIdIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                " is not null AND " + IProductGlossaryChangLogDAO.ApproverId +
                " <> ''");

            return this;
        }

        public Criteria andApproverIdIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.ApproverId +
                " is null OR " + IProductGlossaryChangLogDAO.ApproverId +
                " = '')");

            return this;
        }

        public Criteria andApproverIdEqualTo(long value) {
            return andApproverIdEqualTo(Long.valueOf(value));
        }

        public Criteria andApproverIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " = ", value,
                "approverId");

            return this;
        }

        public Criteria andApproverIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ApproverId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andApproverIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdNotEqualTo(long value) {
            return andApproverIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andApproverIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " <>", value,
                "approverId");

            return this;
        }

        public Criteria andApproverIdNotEqualToOrIsNull(long value) {
            return andApproverIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andApproverIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                " is null OR " + IProductGlossaryChangLogDAO.ApproverId +
                " <>", value, "approverId");

            return this;
        }

        public Criteria andApproverIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ApproverId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andApproverIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdGreaterThan(long value) {
            return andApproverIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andApproverIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " >", value,
                "approverId");

            return this;
        }

        public Criteria andApproverIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ApproverId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andApproverIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdGreaterThanOrEqualTo(long value) {
            return andApproverIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andApproverIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " >=", value,
                "approverId");

            return this;
        }

        public Criteria andApproverIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ApproverId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andApproverIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdLessThan(long value) {
            return andApproverIdLessThan(Long.valueOf(value));
        }

        public Criteria andApproverIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " <", value,
                "approverId");

            return this;
        }

        public Criteria andApproverIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ApproverId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andApproverIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdLessThanOrEqualTo(long value) {
            return andApproverIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andApproverIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " <=", value,
                "approverId");

            return this;
        }

        public Criteria andApproverIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ApproverId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andApproverIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdIn(long[] values) {
            if (values.length == 1) {
                return andApproverIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ApproverId + " in",
                    values, "approverId");

                return this;
            }
        }

        public Criteria andApproverIdNotIn(long[] values) {
            if (values.length == 1) {
                return andApproverIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                    " not in", values, "approverId");

                return this;
            }
        }

        public Criteria andApproverIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andApproverIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ApproverId + " in",
                    values, "approverId");

                return this;
            }
        }

        public Criteria andApproverIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andApproverIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                    " not in", values, "approverId");

                return this;
            }
        }

        public Criteria andApproverIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andApproverIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ApproverId + " in",
                    Arrays.asList(values), "approverId");

                return this;
            }
        }

        public Criteria andApproverIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andApproverIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                    " not in", Arrays.asList(values), "approverId");

                return this;
            }
        }

        public Criteria andApproverIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andApproverIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " between",
                value1, value2, "approverId");

            return this;
        }

        public Criteria andApproverIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId + " between",
                value1, value2, "approverId");

            return this;
        }

        public Criteria andApproverIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                " not between", value1, value2, "approverId");

            return this;
        }

        public Criteria andApproverIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ApproverId +
                " not between", value1, value2, "approverId");

            return this;
        }

        public Criteria andBeforChangeContentIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " is null");

            return this;
        }

        public Criteria andBeforChangeContentIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " is not null");

            return this;
        }

        public Criteria andBeforChangeContentIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " is not null AND " +
                IProductGlossaryChangLogDAO.BeforChangeContent + " <> ''");

            return this;
        }

        public Criteria andBeforChangeContentIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.BeforChangeContent +
                " is null OR " +
                IProductGlossaryChangLogDAO.BeforChangeContent + " = '')");

            return this;
        }

        public Criteria andBeforChangeContentEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " = ", value, "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.BeforChangeContent);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andBeforChangeContentEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentNotEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " <>", value, "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " is null OR " +
                IProductGlossaryChangLogDAO.BeforChangeContent + " <>", value,
                "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.BeforChangeContent);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andBeforChangeContentNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentGreaterThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent + " >",
                value, "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.BeforChangeContent);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andBeforChangeContentGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " >=", value, "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.BeforChangeContent);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andBeforChangeContentGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentLessThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent + " <",
                value, "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.BeforChangeContent);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andBeforChangeContentLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " <=", value, "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.BeforChangeContent);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andBeforChangeContentLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " like", buffer.toString(), "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " not like", buffer.toString(), "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentIn(List<String> values) {
            if (values.size() == 1) {
                return andBeforChangeContentEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                    " in", values, "beforChangeContent");

                return this;
            }
        }

        public Criteria andBeforChangeContentNotIn(List<String> values) {
            if (values.size() == 1) {
                return andBeforChangeContentNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                    " not in", values, "beforChangeContent");

                return this;
            }
        }

        public Criteria andBeforChangeContentIn(String[] values) {
            if (values.length == 1) {
                return andBeforChangeContentEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                    " in", Arrays.asList(values), "beforChangeContent");

                return this;
            }
        }

        public Criteria andBeforChangeContentNotIn(String[] values) {
            if (values.length == 1) {
                return andBeforChangeContentNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                    " not in", Arrays.asList(values), "beforChangeContent");

                return this;
            }
        }

        public Criteria andBeforChangeContentIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andBeforChangeContentBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " between", value1, value2, "beforChangeContent");

            return this;
        }

        public Criteria andBeforChangeContentNotBetween(String value1,
            String value2) {
            addCriterion(IProductGlossaryChangLogDAO.BeforChangeContent +
                " not between", value1, value2, "beforChangeContent");

            return this;
        }

        public Criteria andChangeReasonIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " is null");

            return this;
        }

        public Criteria andChangeReasonIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason +
                " is not null");

            return this;
        }

        public Criteria andChangeReasonIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason +
                " is not null AND " + IProductGlossaryChangLogDAO.ChangeReason +
                " <> ''");

            return this;
        }

        public Criteria andChangeReasonIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.ChangeReason +
                " is null OR " + IProductGlossaryChangLogDAO.ChangeReason +
                " = '')");

            return this;
        }

        public Criteria andChangeReasonEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " = ",
                value, "changeReason");

            return this;
        }

        public Criteria andChangeReasonEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ChangeReason);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andChangeReasonEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonNotEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " <>",
                value, "changeReason");

            return this;
        }

        public Criteria andChangeReasonNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason +
                " is null OR " + IProductGlossaryChangLogDAO.ChangeReason +
                " <>", value, "changeReason");

            return this;
        }

        public Criteria andChangeReasonNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ChangeReason);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andChangeReasonNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonGreaterThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " >",
                value, "changeReason");

            return this;
        }

        public Criteria andChangeReasonGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ChangeReason);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andChangeReasonGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " >=",
                value, "changeReason");

            return this;
        }

        public Criteria andChangeReasonGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ChangeReason);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andChangeReasonGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonLessThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " <",
                value, "changeReason");

            return this;
        }

        public Criteria andChangeReasonLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ChangeReason);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andChangeReasonLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " <=",
                value, "changeReason");

            return this;
        }

        public Criteria andChangeReasonLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ChangeReason);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andChangeReasonLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " like",
                buffer.toString(), "changeReason");

            return this;
        }

        public Criteria andChangeReasonNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason +
                " not like", buffer.toString(), "changeReason");

            return this;
        }

        public Criteria andChangeReasonIn(List<String> values) {
            if (values.size() == 1) {
                return andChangeReasonEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " in",
                    values, "changeReason");

                return this;
            }
        }

        public Criteria andChangeReasonNotIn(List<String> values) {
            if (values.size() == 1) {
                return andChangeReasonNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ChangeReason +
                    " not in", values, "changeReason");

                return this;
            }
        }

        public Criteria andChangeReasonIn(String[] values) {
            if (values.length == 1) {
                return andChangeReasonEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " in",
                    Arrays.asList(values), "changeReason");

                return this;
            }
        }

        public Criteria andChangeReasonNotIn(String[] values) {
            if (values.length == 1) {
                return andChangeReasonNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ChangeReason +
                    " not in", Arrays.asList(values), "changeReason");

                return this;
            }
        }

        public Criteria andChangeReasonIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andChangeReasonBetween(String value1, String value2) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason + " between",
                value1, value2, "changeReason");

            return this;
        }

        public Criteria andChangeReasonNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryChangLogDAO.ChangeReason +
                " not between", value1, value2, "changeReason");

            return this;
        }

        public Criteria andEditorIdIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " is null");

            return this;
        }

        public Criteria andEditorIdIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " is not null");

            return this;
        }

        public Criteria andEditorIdIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.EditorId +
                " is not null AND " + IProductGlossaryChangLogDAO.EditorId +
                " <> ''");

            return this;
        }

        public Criteria andEditorIdIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.EditorId +
                " is null OR " + IProductGlossaryChangLogDAO.EditorId +
                " = '')");

            return this;
        }

        public Criteria andEditorIdEqualTo(long value) {
            return andEditorIdEqualTo(Long.valueOf(value));
        }

        public Criteria andEditorIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " = ", value,
                "editorId");

            return this;
        }

        public Criteria andEditorIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditorId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditorIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdNotEqualTo(long value) {
            return andEditorIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andEditorIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " <>", value,
                "editorId");

            return this;
        }

        public Criteria andEditorIdNotEqualToOrIsNull(long value) {
            return andEditorIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andEditorIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " is null OR " +
                IProductGlossaryChangLogDAO.EditorId + " <>", value, "editorId");

            return this;
        }

        public Criteria andEditorIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditorId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditorIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdGreaterThan(long value) {
            return andEditorIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andEditorIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " >", value,
                "editorId");

            return this;
        }

        public Criteria andEditorIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditorId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditorIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdGreaterThanOrEqualTo(long value) {
            return andEditorIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEditorIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " >=", value,
                "editorId");

            return this;
        }

        public Criteria andEditorIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditorId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditorIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdLessThan(long value) {
            return andEditorIdLessThan(Long.valueOf(value));
        }

        public Criteria andEditorIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " <", value,
                "editorId");

            return this;
        }

        public Criteria andEditorIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditorId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditorIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdLessThanOrEqualTo(long value) {
            return andEditorIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEditorIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " <=", value,
                "editorId");

            return this;
        }

        public Criteria andEditorIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditorId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditorIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdIn(long[] values) {
            if (values.length == 1) {
                return andEditorIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.EditorId + " in",
                    values, "editorId");

                return this;
            }
        }

        public Criteria andEditorIdNotIn(long[] values) {
            if (values.length == 1) {
                return andEditorIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.EditorId + " not in",
                    values, "editorId");

                return this;
            }
        }

        public Criteria andEditorIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEditorIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.EditorId + " in",
                    values, "editorId");

                return this;
            }
        }

        public Criteria andEditorIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEditorIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.EditorId + " not in",
                    values, "editorId");

                return this;
            }
        }

        public Criteria andEditorIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEditorIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.EditorId + " in",
                    Arrays.asList(values), "editorId");

                return this;
            }
        }

        public Criteria andEditorIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEditorIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.EditorId + " not in",
                    Arrays.asList(values), "editorId");

                return this;
            }
        }

        public Criteria andEditorIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditorIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " between",
                value1, value2, "editorId");

            return this;
        }

        public Criteria andEditorIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " between",
                value1, value2, "editorId");

            return this;
        }

        public Criteria andEditorIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " not between",
                value1, value2, "editorId");

            return this;
        }

        public Criteria andEditorIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.EditorId + " not between",
                value1, value2, "editorId");

            return this;
        }

        public Criteria andEditDateIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " is null");

            return this;
        }

        public Criteria andEditDateIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " is not null");

            return this;
        }

        public Criteria andEditDateIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.EditDate +
                " is not null AND " + IProductGlossaryChangLogDAO.EditDate +
                " <> ''");

            return this;
        }

        public Criteria andEditDateIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.EditDate +
                " is null OR " + IProductGlossaryChangLogDAO.EditDate +
                " = '')");

            return this;
        }

        public Criteria andEditDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " = ", value, "editDate");

            return this;
        }

        public Criteria andEditDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " <>", value, "editDate");

            return this;
        }

        public Criteria andEditDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " is null OR " + IProductGlossaryChangLogDAO.EditDate + " <>",
                value, "editDate");

            return this;
        }

        public Criteria andEditDateNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " >", value, "editDate");

            return this;
        }

        public Criteria andEditDateGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditDateGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateGreaterThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " >=", value, "editDate");

            return this;
        }

        public Criteria andEditDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " <", value, "editDate");

            return this;
        }

        public Criteria andEditDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " <=", value, "editDate");

            return this;
        }

        public Criteria andEditDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.EditDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEditDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEditDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                    " in", values, "editDate");

                return this;
            }
        }

        public Criteria andEditDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEditDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                    " not in", values, "editDate");

                return this;
            }
        }

        public Criteria andEditDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEditDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                    " in", Arrays.asList(values), "editDate");

                return this;
            }
        }

        public Criteria andEditDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEditDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                    " not in", Arrays.asList(values), "editDate");

                return this;
            }
        }

        public Criteria andEditDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.EditDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEditDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " between", value1, value2, "editDate");

            return this;
        }

        public Criteria andEditDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductGlossaryChangLogDAO.EditDate +
                " not between", value1, value2, "editDate");

            return this;
        }

        public Criteria andProductGlossaryIdIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " is null");

            return this;
        }

        public Criteria andProductGlossaryIdIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " is not null");

            return this;
        }

        public Criteria andProductGlossaryIdIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " is not null AND " +
                IProductGlossaryChangLogDAO.ProductGlossaryId + " <> ''");

            return this;
        }

        public Criteria andProductGlossaryIdIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.ProductGlossaryId +
                " is null OR " + IProductGlossaryChangLogDAO.ProductGlossaryId +
                " = '')");

            return this;
        }

        public Criteria andProductGlossaryIdEqualTo(long value) {
            return andProductGlossaryIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " = ",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ProductGlossaryId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualTo(long value) {
            return andProductGlossaryIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " <>",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualToOrIsNull(long value) {
            return andProductGlossaryIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " is null OR " + IProductGlossaryChangLogDAO.ProductGlossaryId +
                " <>", value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ProductGlossaryId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThan(long value) {
            return andProductGlossaryIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " >",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ProductGlossaryId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(long value) {
            return andProductGlossaryIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " >=",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ProductGlossaryId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdLessThan(long value) {
            return andProductGlossaryIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " <",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ProductGlossaryId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(long value) {
            return andProductGlossaryIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId + " <=",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.ProductGlossaryId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdIn(long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                    " in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                    " not in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductGlossaryIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                    " in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductGlossaryIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                    " not in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                    " in", Arrays.asList(values), "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                    " not in", Arrays.asList(values), "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " not between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryChangLogDAO.ProductGlossaryId +
                " not between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.Remarks +
                " is not null AND " + IProductGlossaryChangLogDAO.Remarks +
                " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.Remarks +
                " is null OR " + IProductGlossaryChangLogDAO.Remarks +
                " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " = ", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " <>", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " is null OR " +
                IProductGlossaryChangLogDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " >", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " >=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " <", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " <=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " not like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Remarks + " in",
                    values, "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Remarks + " not in",
                    values, "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Remarks + " in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Remarks + " not in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " between",
                value1, value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryChangLogDAO.Remarks + " not between",
                value1, value2, "remarks");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductGlossaryChangLogDAO.Status + " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductGlossaryChangLogDAO.Status + " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductGlossaryChangLogDAO.Status +
                " is not null AND " + IProductGlossaryChangLogDAO.Status +
                " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductGlossaryChangLogDAO.Status +
                " is null OR " + IProductGlossaryChangLogDAO.Status + " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " = ", value,
                "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " <>", value,
                "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " is null OR " +
                IProductGlossaryChangLogDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " >", value,
                "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " >=", value,
                "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " <", value,
                "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " <=", value,
                "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryChangLogDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryChangLogDAO.Status + " not like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Status + " in",
                    values, "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Status + " not in",
                    values, "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Status + " in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryChangLogDAO.Status + " not in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " between",
                value1, value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryChangLogDAO.Status + " not between",
                value1, value2, "status");

            return this;
        }
    }
}
